package cn.tedu.csmall.product.service.impl;

import cn.tedu.csmall.commons.ex.ServiceException;
import cn.tedu.csmall.commons.pojo.vo.PageData;
import cn.tedu.csmall.commons.util.PageInfoToPageDataConverter;
import cn.tedu.csmall.commons.web.ServiceCode;
import cn.tedu.csmall.product.mapper.AlbumMapper;
import cn.tedu.csmall.product.mapper.AttributeMapper;
import cn.tedu.csmall.product.mapper.AttributeTemplateMapper;
import cn.tedu.csmall.product.mapper.PictureMapper;
import cn.tedu.csmall.product.pojo.entity.Album;
import cn.tedu.csmall.product.pojo.entity.Attribute;
import cn.tedu.csmall.product.pojo.entity.BrandCategory;
import cn.tedu.csmall.product.pojo.entity.Picture;
import cn.tedu.csmall.product.pojo.param.AttributeAddNewParam;
import cn.tedu.csmall.product.pojo.param.AttributeUpdateInfoParam;
import cn.tedu.csmall.product.pojo.param.PictureAddNewParam;
import cn.tedu.csmall.product.pojo.vo.*;
import cn.tedu.csmall.product.service.IAttributeService;
import cn.tedu.csmall.product.service.PictureService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

@Service
@Slf4j
public class AttributeServiceImpl implements IAttributeService {

    @Autowired
    private AttributeMapper mapper;
    @Autowired
    private AttributeTemplateMapper attributeTemplateMapper;

    @Override
    public void addNew(AttributeAddNewParam attributeAddNewParam) {
        log.info("开始:【新增属性】");
        log.debug("传入参数,attributeAddNewParam={}", attributeAddNewParam);

        //根据属性模板下是否存在同名属性
        QueryWrapper<Attribute> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.eq("template_id", attributeAddNewParam.getTemplateId());
        queryWrapper2.eq("name", attributeAddNewParam.getName());
        Integer count = mapper.selectCount(queryWrapper2);
        log.info("规则：根据属性名、模板id检索数据库,count={}", count);
        if(count > 0){
            log.info("结果2:根据类别id检索属性数据量>0，抛出异常...");
            String message = "新增属性失败，属性模板内有同名数据数据！";
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        //检查属性模板是否存在
        AttributeTemplateStandardVO standardById = attributeTemplateMapper.getStandardById(attributeAddNewParam.getTemplateId());
        log.info("业务：根据属性模板ID检索数据,standardById={}", standardById);
        if(standardById==null){
            log.info("结果3:根据属性模板id查询，结果为null，抛出异常...");
            String message = "新增属性失败，属性模板不存在";
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        Attribute attribute = new Attribute();
        BeanUtils.copyProperties(attributeAddNewParam,attribute);
        attribute.setGmtCreate(LocalDateTime.now()).setGmtModified(LocalDateTime.now());

        log.debug("新增属性数据,attribute={}", attribute);
        int rows = mapper.insert(attribute);
        if(rows != 1){
            log.info("结果1:数据返回行数不满足预估行数，预估={}, 实际={}, 抛出自定异常...", 1, rows);
            String message = "添加属性失败，服务器忙，请稍后再试！";
            throw new ServiceException(ServiceCode.ERR_INSERT, message);
        }
        log.info("结果1:新增属性结果,rows={}", rows);
    }

    @Override
    public void deleteById(Long id) {
        log.info("开始:【删除属性】");
        log.debug("传入参数,id={}", id);

        //检查属性ID检查属性是否存在数据，如果不存在，则抛出异常
        AttributeStandardVO standardById = mapper.getStandardById(id);
        log.info("规则：根据属性id检索数据库结果,standardById={}", standardById);
        if(standardById == null){
            String message = "删除属性失败，属性数据不存在！";
            log.info("结果2:根据属性id检索数据量为0，抛出异常...");
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        int rows = mapper.deleteById(id);
        if(rows != 1){
            String message = "删除属性失败，服务器忙，请稍后再试！";
            log.info("结果1:数据返回行数不满足预估行数，预估={}, 实际={}, 抛出自定异常...", 1, rows);
            throw new ServiceException(ServiceCode.ERR_DELETE, message);
        }
        log.info("结果1:删除属性结果,rows={}", rows);
    }

    @Override
    public void updateInfoById(Long id, AttributeUpdateInfoParam attributeUpdateInfoParam) {
        log.info("开始:【根据id编辑属性】");
        log.debug("传入参数,id={},attributeUpdateInfoParam={}", id, attributeUpdateInfoParam);
        //检查属性ID是否存在数据，如果不存在，则抛出异常
        AttributeStandardVO standardById = mapper.getStandardById(id);
        log.info("规则：根据属性ID检索数据库结果,standardById={}", standardById);
        if(standardById == null){
            String message = "更新属性失败，属性数据不存在！";
            log.info("结果2:根据属性ID检索数据量为0，抛出异常...");
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        //根据属性模板下是否存在同名属性
        QueryWrapper<Attribute> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.eq("template_id", standardById.getTemplateId());
        queryWrapper2.eq("name", attributeUpdateInfoParam.getName());
        Integer count = mapper.selectCount(queryWrapper2);
        log.info("规则：根据属性名、模板id检索数据库,count={}", count);
        if(count > 0){
            log.info("结果3:根据类别id检索属性数据量>0，抛出异常...");
            String message = "更新属性失败，属性模板内有同名数据数据！";
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        Attribute attribute = new Attribute();
        BeanUtils.copyProperties(attributeUpdateInfoParam,attribute);
        attribute.setId(id).setGmtModified(LocalDateTime.now());

        log.debug("更新属性数据,attribute={}", attribute);
        int rows = mapper.updateById(attribute);
        if(rows != 1){
            log.info("结果1:数据返回行数不满足预估行数，预估={}, 实际={}, 抛出自定异常...", 1, rows);
            String message = "编辑属性失败，服务器忙，请稍后再试！";
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
        log.info("结果1:根据id编辑属性结果,rows={}", rows);
    }

    @Override
    public AttributeStandardVO getStandardById(Long id) {
        log.info("开始:【根据ID查询属性】");
        log.debug("传入参数,id={}", id);
        AttributeStandardVO standardById = mapper.getStandardById(id);

        //根据属性ID检查属性是否存在数据，如果不存在，则抛出异常
        if(standardById==null){
            log.info("结果2:根据属性id查询详情，结果为null，抛出异常...");
            String message = "查询属性详情失败，属性数据不存在";
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        log.info("结果1:查询出数据,standardById");
        return standardById;
    }

    @Override
    public PageData<AttributeListItemVO> listByTemplateId(Long templateId, Integer pageNum) {
        Integer pageSize = 5;
        return listByTemplateId(templateId, pageNum, pageSize);
    }

    @Override
    public PageData<AttributeListItemVO> listByTemplateId(Long templateId, Integer pageNum, Integer pageSize) {
        log.info("开始:【查询-属性-分页】");
        log.debug("传入参数, templateId={}, pageNum={}, pageSize={}", templateId, pageNum, pageSize);
        PageHelper.startPage(pageNum, pageSize);
        List<AttributeListItemVO> list = mapper.listByTemplateId(templateId);
        PageInfo<AttributeListItemVO> pageInfo = new PageInfo<>(list);
        PageData<AttributeListItemVO> pageData = PageInfoToPageDataConverter.converter(pageInfo);
        log.debug("结果1: 查询结果：pageData={}", pageData);
        return pageData;
    }
}
